import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;

public class Main {
    public static void main(String[] args) {

    }
    public static void main4(String[] args) {
        // 简单算法洗牌

    }

    //杨辉三角
    public  List<List<Integer>> generate(int numRows){//List<List<Integer>>表示一个二维数组
        // 实例化
        List<List<Integer>> ret = new ArrayList<>();

        //第一行的list
        List<Integer> row = new ArrayList<>();
        row.add(1);
        ret.add(row); //把行放进去

        for (int i = 1; i < numRows; i++) {  // 从第二行开始
            List<Integer> curRow = new ArrayList<>();
            List<Integer> prevRow = ret.get(i-1);  // 代表前一行
            curRow.add(1); // 一行开头的1

            // 中间curRow list赋值
            for (int j = 1; j < i; j++) {   //j所活动的范围
                int x = prevRow.get(j)+ prevRow.get(j-1);
                curRow.add(x);
            }
            curRow.add(1); //一行中最后一个1
            ret.add(curRow);
        }
        return ret;
    }
    public static void main3(String[] args) {
        // 杨辉三角

    }
    public static void main2(String[] args) {
        //****ArrayList的具体使用****
        //删除 在s1中出现的s2的字母
        ArrayList<Character> list = new ArrayList<>();
        String s1 = "welcome to bit";
        String s2 = "come";
        for (int i = 0; i < s1.length(); i++) {
            char ch = s1.charAt(i);
            if(!s2.contains(ch+"")){//这一行的意思是判断s2中是否没有字符ch，但是判断字符是不行的，要将ch转换成字符串，所以+"";
                // 以为 s2.contains 有一个接口是只能判定字符串
                list.add(ch);
            }
        }
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }



    }
    public static void main1(String[] args) {
        //****ArrayList****

        // 把对象变成字符串叫做序列化
        // 把字符串变成对象叫做反序列化
        ArrayList<Integer> arrayList = new ArrayList<>();
        //****ArrayList的使用****
        //***ArrayList的构造****
        //ArrayList<Integer> arrayList = new ArrayList<>(); 这个代码写完之后并没有为数组分配内存大小
        arrayList.add(11);
        arrayList.add(12);
        arrayList.add(13);
        arrayList.add(14);
        arrayList.add(15);
        arrayList.add(16);
        arrayList.add(17);
        // 在第一次add的时候才会为ArrayList底层的elementData分配内存且大小为10; 1.5倍扩容
        ArrayList<Integer> arrayList1 = new ArrayList<>(10); //这个是直接分配内存大小

        //第三种构造方法类型，
        LinkedList<Integer> list = new LinkedList<>();
        list.add(11);
        list.add(12);
        list.add(13);
        ArrayList<Integer> arrayList2 = new ArrayList<>(list);  //泛型的继承
        //这里面的list必须是ArrayList<Integer>中的Integer或者其子类
        arrayList2.add(1);
        System.out.println(arrayList2);

        arrayList.add(0,10);
        arrayList.remove(new Integer(10));
        arrayList.get(0);
        //截取
        List<Integer> sub = arrayList2.subList(1,3);
        System.out.println(sub);
        sub.set(0,99);//0 下标更新为99
        System.out.println(arrayList2);  // sub并不是只将截取的数组改变，而是全部改变；并不是浅拷贝


        //***ArrayList的遍历***
        // sout 直接输出
        // for 进行输出

        for (int i = 0; i < arrayList.size(); i++) {
            System.out.print(arrayList.get(i)+" ");
        }
        //for-each进行输出
        //迭代器进行输出
        ListIterator<Integer> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            System.out.println(listIterator.next()+" ");  // 这一行的意思是打印listIterator，同时让listIterator++

        }

        //***ArrayList的扩容机制***
        // 按照1.5倍的方式进行扩容的 copyOf

    }
}